/**
 * MCP 服务器核心逻辑
 * 这个模块实现了MCP协议的核心功能，包括：
 * - 服务器初始化
 * - 工具注册和管理
 * - 请求处理和响应
 * - 错误处理
 * 
 * 重要说明：
 * - MCP服务器使用标准输入输出(stdio)进行通信
 * - StdioServerTransport会自动管理进程生命周期
 * - 不需要手动保持进程运行，transport会处理所有细节
 * - 服务器会持续运行直到收到退出信号或输入关闭
 */

import { timeTools } from './tools/timeTools.js';

// 简单的 MCP 服务器实现
class SimpleMCPServer {
  constructor() {
    this.tools = timeTools;
  }

  // 处理 JSON-RPC 请求
  async handleRequest(request) {
    const { id, method, params } = request;
    
    try {
      let result;
      
      switch (method) {
        case 'initialize':
          result = await this.handleInitialize(params);
          break;
        case 'tools/list':
          result = await this.handleToolsList();
          break;
        case 'tools/call':
          result = await this.handleToolCall(params);
          break;
        case 'ping':
          result = { content: [{ type: "text", text: "pong" }] };
          break;
        default:
          throw new Error(`未知方法: ${method}`);
      }
      
      return {
        jsonrpc: "2.0",
        id,
        result
      };
      
    } catch (error) {
      return {
        jsonrpc: "2.0",
        id,
        error: {
          code: -32603,
          message: error.message
        }
      };
    }
  }

  // 处理初始化请求
  async handleInitialize(params) {
    process.stderr.write("[MCP] 收到初始化请求\n");
    return {
      protocolVersion: "2024-11-05",
      capabilities: {
        tools: {}
      },
      serverInfo: {
        name: "time-mcp-server",
        version: "1.0.0"
      }
    };
  }

  // 处理工具列表请求
  async handleToolsList() {
    process.stderr.write("[MCP] 收到工具列表请求\n");
    return {
      tools: this.tools.map(tool => ({
        name: tool.name,
        description: tool.description,
        inputSchema: tool.inputSchema
      }))
    };
  }

  // 处理工具调用请求
  async handleToolCall(params) {
    const { name, arguments: args } = params;
    process.stderr.write(`[MCP] 收到工具调用请求: ${name} ${JSON.stringify(args)}\n`);

    const tool = this.tools.find(t => t.name === name);
    if (!tool) {
      throw new Error(`工具 '${name}' 不存在`);
    }

    try {
      const result = await tool.handler(args);
      process.stderr.write(`[MCP] 工具 ${name} 执行成功\n`);
      return result;
    } catch (error) {
      process.stderr.write(`[MCP] 工具 ${name} 执行失败: ${error}\n`);
      throw error;
    }
  }
}

export async function startServer() {
  try {
    process.stderr.write("[MCP] 正在启动MCP时间服务器...\n");
    
    const server = new SimpleMCPServer();
    
    // 处理标准输入输出
    process.stdin.setEncoding('utf8');
    process.stdout.setEncoding('utf8');
    
    process.stdin.on('data', async (data) => {
      try {
        const lines = data.toString().trim().split('\n');
        
        for (const line of lines) {
          if (line.trim()) {
            let request;
            try {
              request = JSON.parse(line);
            } catch (err) {
              // 非法 JSON，返回协议错误，但不输出到 stdout 以外
              const errorResponse = {
                jsonrpc: "2.0",
                id: null,
                error: {
                  code: -32700,
                  message: "Parse error"
                }
              };
              process.stdout.write(JSON.stringify(errorResponse) + '\n');
              process.stderr.write(`[MCP] 收到非法 JSON: ${line}\n`);
              continue;
            }
            const response = await server.handleRequest(request);
            if (response) {
              process.stdout.write(JSON.stringify(response) + '\n');
            }
          }
        }
      } catch (error) {
        process.stderr.write(`[MCP] 处理请求时出错: ${error}\n`);
      }
    });
    
    process.stderr.write("[MCP] MCP时间服务器启动成功！\n");
    process.stderr.write("[MCP] 可用工具:\n");
    server.tools.forEach(tool => {
      process.stderr.write(`  - ${tool.name}: ${tool.description}\n`);
    });
    process.stderr.write("[MCP] 等待 MCP 客户端连接...\n");
    
    // 设置优雅关闭
    setupGracefulShutdown();
    
  } catch (error) {
    process.stderr.write(`[MCP] 服务器启动失败: ${error}\n`);
    process.exit(1);
  }
}

export function setupGracefulShutdown() {
  const shutdown = async (signal) => {
    process.stderr.write(`[MCP] 收到 ${signal} 信号，正在关闭服务器...\n`);
    process.exit(0);
  };

  process.on('SIGINT', () => shutdown('SIGINT'));
  process.on('SIGTERM', () => shutdown('SIGTERM'));
} 